package com.wh.wisdomsite.xbox.utils;

import org.apache.commons.lang3.StringEscapeUtils;

import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
import java.io.StringReader;
import java.io.UnsupportedEncodingException;
import java.sql.Timestamp;
import java.text.DateFormat;
import java.text.NumberFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class StringUtils {
	public static final String EMPTY = "";

	/**
	 * 如果str为null，返回“”,否则返回str
	 *
	 * @param str
	 * @return
	 */
	public static String isNull(String str) {
		if (str == null|| "".equals(str) || "".equals(str.trim()) ) {
			return "";
		}
		return str;
	}

	/**
	 * 缩略字符串（不区分中英文字符）
	 * @param str 目标字符串
	 * @param length 截取长度
	 * @return
	 */
	public static String abbr(String str, int length) {
		if (str == null) {
			return "";
		}
		try {
			StringBuilder sb = new StringBuilder();
			int currentLength = 0;
			for (char c : replaceHtml(StringEscapeUtils.unescapeHtml4(str)).toCharArray()) {
				currentLength += String.valueOf(c).getBytes("GBK").length;
				if (currentLength <= length - 3) {
					sb.append(c);
				} else {
					sb.append("...");
					break;
				}
			}
			return sb.toString();
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
		return "";
	}

	/**
	 * 替换掉HTML标签方法
	 */
	public static String replaceHtml(String html) {
		if (isBlank(html)){
			return "";
		}
		String regEx = "<.+?>";
		Pattern p = Pattern.compile(regEx);
		Matcher m = p.matcher(html);
		String s = m.replaceAll("");
		return s;
	}

	/**
	 * 获得用户远程地址
	 */
	public static String getRemoteAddr(HttpServletRequest request){
		String remoteAddr = request.getHeader("X-Real-IP");
		if (isNotBlank(remoteAddr)) {
			remoteAddr = request.getHeader("X-Forwarded-For");
		}else if (isNotBlank(remoteAddr)) {
			remoteAddr = request.getHeader("Proxy-Client-IP");
		}else if (isNotBlank(remoteAddr)) {
			remoteAddr = request.getHeader("WL-Proxy-Client-IP");
		}
		return remoteAddr != null ? remoteAddr : request.getRemoteAddr();
	}

	public static boolean isNotBlank(CharSequence cs) {
		return !isBlank(cs);
	}

	public static boolean isBlank(CharSequence cs) {
		int strLen;
		if(cs != null && (strLen = cs.length()) != 0) {
			for(int i = 0; i < strLen; ++i) {
				if(!Character.isWhitespace(cs.charAt(i))) {
					return false;
				}
			}

			return true;
		} else {
			return true;
		}
	}



	/**
	 * 判断字符串是否为空
	 *
	 * @param str
	 * @return
	 */
	public static boolean isEmpty(String str) {
		if (str == null || "".equals(str) || "".equals(str.trim()) || "null".equalsIgnoreCase(str)) {
			return true;
		}
		return false;
	}

	/**
	 * 去掉字符串中的空格
	 * @author 张波
	 * @param str
	 * @return
	 */
	public static String ridSpace(String str){
		return str.trim();
	}

	public static String substring(String str, int start, int end) {
		if (str == null) {
			return null;
		}
		// handle negatives
		if (end < 0) {
			end = str.length() + end; // remember end is negative
		}
		if (start < 0) {
			start = str.length() + start; // remember start is negative
		}
		// check length next
		if (end > str.length()) {
			end = str.length();
		}
		// if start is greater than end, return ""
		if (start > end) {
			return EMPTY;
		}
		if (start < 0) {
			start = 0;
		}
		if (end < 0) {
			end = 0;
		}
		return str.substring(start, end);
	}

	/**
	 * 如果o为null，返回“”,否则返回str
	 *
	 * @param
	 * @return
	 */
	public static String isNull(Object o) {
		if (o == null) {
			return "";
		}
		String str = "";
		if (o instanceof String) {
			str = (String) o;
		} else {
			str = o.toString();
		}
		return str;
	}

	/**
	 * 验证输入密码是否符合要求 (6-18位)
	 *
	 * @param  str //待验证的字符串
	 * @return 如果是符合格式的字符串,返回 <b>true </b>,否则为 <b>false </b>
	 */
	public static boolean isPassword(String str) {
		String regex = "^[a-zA-Z0-9]{6,18}$";
		return match(regex, str);
	}

	/**
	 * 验证登陆名称是否符合要求,用户名正则，4到16位（字母，数字，下划线，减号）
	 *
	 * @param  str //待验证的字符串
	 * @return 如果是符合格式的字符串,返回 <b>true </b>,否则为 <b>false </b>
	 */
	public static boolean isLoginName(String str) {
		String regex = "^[a-zA-Z0-9_-]{4,16}$";
		return match(regex, str);
	}

	/**
	 * @param regex
	 * 正则表达式字符串
	 * @param str
	 * 要匹配的字符串
	 * @return 如果str 符合 regex的正则表达式格式,返回true, 否则返回 false;
	 */
	private static boolean match(String regex, String str) {
		Pattern pattern = Pattern.compile(regex);
		Matcher matcher = pattern.matcher(str);
		return matcher.matches();
	}

	/**
	 * 判断字符串是否为整数
	 *
	 * @param str
	 * @return
	 */
	public static boolean isInteger(String str) {
		if (isEmpty(str)) {
			return false;
		}
		Pattern regex = Pattern.compile("\\d*");
		Matcher matcher = regex.matcher(str);
		boolean isMatched = matcher.matches();
		return isMatched;
	}

	/**
	 * 判断字符串是否为数字
	 *
	 * @param str
	 * @return
	 */
	public static boolean isNumber(String str) {
		if (isEmpty(str)) {
			return false;
		}

		Pattern regex = Pattern.compile("\\d*(.\\d*)?");
		Matcher matcher = regex.matcher(str);
		boolean isMatched = matcher.matches();
		return isMatched;
	}


	/**
	 * 检索内容(并返回内容第一张图全路径)(规则 <img src="xx.png" alt="xx" title="xx" />)");
	 * (src|SRC)=(\"|\')(.*?)(\"|\')
	 * src*=*\"([^\"]+)\"
	 * <img[^>]+src\s*=\s*['"]([^'"]+)['"][^>]*>
	 * <img[\w\W]*?src=["|']?([\w\W]*?)(jpg|png)[\w\W]*?/>
	 * <img[^<>]*src=[\'\"]([0-9A-Za-z.\\/]*)[\'\"].(.*?)>
	 * @param content
	 * @return
	 */
	public static String checkPicFirst(String content) {
		//未检索(返回默认)
		if(StringUtils.isEmpty(content)){
			return "";
		}
		//检索图片正则
		Pattern p = Pattern.compile("<img[^>]+src\\s*=\\s*['\"]([^'\"]+)['\"][^>]*>", Pattern.CASE_INSENSITIVE);
		Matcher m = p.matcher(content);
		//未检索(返回默认)
		if(!m.find() || 0 == m.groupCount()){
			return "";
		}
		//重新构造matcher（groupCount，他不是最终匹配的结果数，他只是子模式匹配的结果数，一般情况下子模式有几个，他就是几。）
		Matcher matcher = p.matcher(content);
		while(matcher.find()){
			return matcher.group(1);
		}
		return "";
	}


	/**
	 * 检索内容（并返回完整图片内容）
	 * (src|SRC)=(\"|\')(.*?)(\"|\')
	 * src*=*\"([^\"]+)\"
	 * <img[^>]+src\s*=\s*['"]([^'"]+)['"][^>]*>
	 * <img[\w\W]*?src=["|']?([\w\W]*?)(jpg|png)[\w\W]*?/>
	 * <img[^<>]*src=[\'\"]([0-9A-Za-z.\\/]*)[\'\"].(.*?)>
	 * @param content  检索内容
	 * @param path 默认跟路径
	 * @return
	 */
	public static String checkPic(String content, String path) {
		//未检索(返回默认)
		if(StringUtils.isEmpty(content)){
			return "";
		}
		//检索图片正则

		Pattern p = Pattern.compile("<img[^>]+src\\s*=\\s*['\"]([^'\"]+)['\"][^>]*>", Pattern.CASE_INSENSITIVE);
		Matcher m = p.matcher(content);
		//未检索(返回默认)
		if(!m.find() || 0 == m.groupCount()){
			return content;
		}

		//重新构造matcher（groupCount，他不是最终匹配的结果数，他只是子模式匹配的结果数，一般情况下子模式有几个，他就是几。）
		Matcher matcher = p.matcher(content);
		while(matcher.find()){
			String src = matcher.group(1);
			String newSrc = path + matcher.group(1);
			content = content.replace(src, newSrc);
		}
		return content;
	}


	/**
	 * 验证手机号码
	 * 1. 精确到号段验证
	 * 移动号码段:139、138、137、136、135、134、150、151、152、157、158、159、182、183、187、188、147
	 * 联通号码段:130、131、132、136、185、186、145
	 * 电信号码段:133、153、180、189
	 * 2. 大概规则验证
	 * @param phone
	 * @return
	 */
	public static boolean checkPhone(String phone) {
		//1.正则表达式（根据号段新增而改变）
		//String regex = "^((13[0-9])|(14[5|7])|(15([0-3]|[5-9]))|(18[0,5-9]))\\d{8}$";
		//2.大概规则验证
		//String regex = "^1[3|4|5|7|6|8][0-9]{9}$";
		Pattern regex = Pattern.compile("^1[3|4|5|7|6|8][0-9]{9}$");
		return regex.matcher(phone).matches();
	}




	/**
	 * 字符串首字母大写
	 * @param str
	 * @return
	 */
	public static String toUpperCaseFirstOne(String str) {
		if (str == null || "".equals(str))
			return str;
		if (Character.isUpperCase(str.charAt(0)))
			return str;
		else
			return (new StringBuilder()).append(Character.toUpperCase(str.charAt(0))).append(str.substring(1))
					.toString();
	}


	public static String trimToEmpty(String str) {
		return str == null ? EMPTY : str.trim();
	}

	/**
	 * 字符串首字母小写
	 * @param str
	 * @return
	 */
	public static String toLowerCaseFirstOne(String str) {
		if (str == null || "".equals(str))
			return str;
		if (Character.isLowerCase(str.charAt(0)))
			return str;
		else
			return (new StringBuilder()).append(Character.toLowerCase(str.charAt(0))).append(str.substring(1))
					.toString();
	}

	/**
	 * 隐藏指定字符
	 * @param  str 要操作的字符串
	 * 		   len 隐藏字符的位置
	 * @update 张波
	 * @updateTime 2015-3-3
	 *
	 * */
	public static String hideChar(String str, int len) {
		if (str == null)
			return null;
		char[] chars = str.toCharArray();
		for (int i = 1; i <chars.length - 1; i++) {
			if (i < len) {
				chars[i] = '*';
			}
		}
		str = new String(chars);
		return str;
	}
	/**
	 * 隐藏首字符
	 * @param  str 要操作的字符串
	 * @update tianding
	 * @updateTime 2015-3-3
	 *
	 * */
	public static String hideFirstChar(String str) {
		if (str == null)
			return null;
		char[] chars = str.toCharArray();
		for (int i = 0; i < 1; i++) {
			chars[i] = '*';
		}
		str = new String(chars);
		return str;
	}

	/**
	 投标记录脱敏处理规则：
	 a.	用户名字符长度 >= 6 : 后4位明文显示，前面N位脱敏为4个”*”点位符；
	 b.	3 < = 用户名字符长度 <= 5 : 后2位明文显示，前面几位数脱敏为4个”*”点位符；
	 c.	用户名字符长度 == 2 : 后1位明文显示，前面1位数脱敏为4个”*”点位符；
	 * @param userName
	 * @return
	 */
	public static String hideUserName(String userName){
		if(userName == null || userName.length() == 0){
			return "";
		}else if(userName.length() == 2){
			return "****" + userName.substring(userName.length() - 1, userName.length());
		}else if(3 <= userName.length() && userName.length() <= 5){
			return "****" + userName.substring(userName.length() - 2, userName.length());
		}else if(6 <= userName.length()){
			return "****" + userName.substring(userName.length() - 4, userName.length());
		}
		return userName;
	}

	/**
	 * 隐藏首字符
	 * @param  str 要操作的字符串
	 * 		   len 隐藏最后字符的长度，如3，则后面3个字符隐藏
	 * @update 张波
	 * @updateTime 2015-3-3
	 *
	 * */
	public static String hideLastChar(String str, int len) {
		if (str == null)
			return null;
		char[] chars = str.toCharArray();
		if (str.length() <= len) {
			for (int i = 0; i < chars.length; i++) {
				chars[i] = '*';
			}
		} else {
			for (int i = chars.length - 1; i > chars.length - len - 1; i--) {
				chars[i] = '*';
			}
		}
		str = new String(chars);
		return str;
	}


	/**
	 * 将指定区域的字符隐藏，如(“eewzsssd”,3,5)则返回结果为 eew**ssd
	 * @param str
	 * @param index1
	 * @param index2
	 * @return
	 */
	public static String hideStr(String str, int index1, int index2) {
		if (str == null)
			return null;
		String str1 = str.substring(index1, index2);
		String str2 = str.substring(index2);
		String str3 = "";
		if (index1 > 0) {
			str1 = str.substring(0, index1);
			str2 = str.substring(index1, index2);
			str3 = str.substring(index2);
		}
		char[] chars = str2.toCharArray();
		for (int i = 0; i < chars.length; i++) {
			chars[i] = '*';
		}
		str2 = new String(chars);
		String str4 = str1 + str2 + str3;
		return str4;
	}


	/**
	 * 格式化字符串,如果给定的len小于str的长度，则截取字符str长度为 len,如果len大于str的长度，则在str的前面添加0，长度为len-str.length
	 * @update 张波
	 * @updateTime 2015-3-3
	 * @return
	 */
	public static String format(String str, int len) {
		if (str == null)
			return "-";
		if (str.length() <= len) {
			int pushlen = len - str.length();
			StringBuffer sb = new StringBuffer();
			for (int i = 0; i < pushlen; i++) {
				sb.append("0");
			}
			sb.append(str);
			str = sb.toString();
		} else {
			String newStr = str.substring(0, len);
			str = newStr;
		}
		return str;
	}

	/**
	 * 判断 字符串 s 是否包含 给定字符串  type
	 * @update zhangbo
	 * @updateTime 2015-3-3
	 * @param s
	 * @param type
	 * @return
	 */
	public static boolean isInSplit(String s, String type) {
		if (isNull(s).equals("")) {
			return false;
		}
		List<String> list = Arrays.asList(s.split(","));
		if (list.contains(type)) {
			return true;
		}
		return false;
	}


	/**
	 * 判断给定字符是否为空,是返回true,不是返回 false
	 * @update zhangbo
	 * @updateTime 2015-3-3
	 *
	 * */
	public static boolean isBlank(String str) {
		return StringUtils.isNull(str).equals("");
	}


	/**
	 * 将对象数据组中的对象，以字符串的形式返回，以“，”隔开
	 * @update 张波
	 * @updateTime 2015-3-3
	 *
	 * */
	public static String array2Str(Object[] arr) {
		StringBuffer s = new StringBuffer();
		for (int i = 0; i < arr.length; i++) {
			s.append(arr[i]);
			if (i < arr.length - 1) {
				s.append(",");
			}
		}
		return s.toString();
	}

	/**
	 * 将int数据组，以字符串的形式返回，以“，”隔开
	 * @update 张波
	 * @updateTime 2015-3-3
	 *
	 * */
	public static String array2Str(int[] arr) {
		StringBuffer s = new StringBuffer();
		for (int i = 0; i < arr.length; i++) {
			s.append(arr[i]);
			if (i < arr.length - 1) {
				s.append(",");
			}
		}
		return s.toString();
	}

	/**
	 * 将字符串形式的小数传入，进行四舍五入处理保留两位小数点
	 * @param str
	 * @update zhangbo
	 * @updateTime 2015-3-3
	 *
	 *
	 * */
	public static String round(String str) {
		NumberFormat nf = NumberFormat.getNumberInstance();
		nf.setMaximumFractionDigits(2);
		nf.setMinimumFractionDigits(2);
		return nf.format(Float.valueOf(str));
	}



	/**
	 *
	 * 将给定的字符串 templet 中的 phstr 替换成 字符串数组中的元素，如 fillTemplet("ddffee","ff",{"33"})
	 * 则返回 dd33ee
	 * @updateTime 2015-3-3
	 *
	 * */
	public static String fillTemplet(String templet, String phstr,
									 String[] paras) {
		StringBuffer templetSB = new StringBuffer(templet);
		int i = 0;
		while (templetSB.indexOf(phstr) >= 0 && i < paras.length) {
			templetSB.replace(templetSB.indexOf(phstr),
					templetSB.indexOf(phstr) + phstr.length(), paras[i]);
			i++;
		}
		return templetSB.toString();
	}

	/**
	 * 将字符串数组转换为int数组
	 * @param
	 * @updateTime 2015-3-3
	 *
	 * */
	public static int[] strarr2intarr(String[] strarr) {
		int[] result = new int[strarr.length];
		for (int i = 0; i < strarr.length; i++) {
			result[i] = Integer.parseInt(strarr[i]);
		}
		return result;
	}

	/**
	 * 获取给定日期转换为yyyy-MM-dd HH:mm:ss格式的时间字符串
	 * @update zhangbo
	 * @updateTime 2015-3-3
	 *
	 * */
	public static String getStr(Date date) {
		SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		return df.format(date);
	}

	/**
	 * 将给定的日期dataString格式为yyyy-MM-dd HH:mm:ss转换为Date格式
	 * @update zhangbo
	 * @updateTime 2015-3-3
	 * */
	public final static Date string2Date(String dateString)
			throws Exception {
		DateFormat dateFormat;
		dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.ENGLISH);
		dateFormat.setLenient(false);
		Date timeDate = dateFormat.parse(dateString);// util类型
		return timeDate;
	}
	/**
	 * 计算出给定时间与特定时间1970/01/01 08:00:00的时间差，最后返回秒数
	 *
	 *
	 * */
	public final static long getTimestamp(String sTime) throws ParseException {
		System.out.println(sTime);
		Timestamp ts = Timestamp.valueOf(sTime);
		Date date2 = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss")
				.parse("1970/01/01 08:00:00");
		long l = ts.getTime() - date2.getTime() > 0 ? ts.getTime()
				- date2.getTime() : date2.getTime() - ts.getTime();
		long rand = (int) (l / 1000);

		return rand;
	}


	/**
	 * 将字符串str中的子串old替换成newStr
	 * @param str 要操作的字符串
	 * 		  old 要替换的字符串
	 * 		  newStr 新的字符串
	 * @updateTime 2015-3-3
	 * */
	public final static String replace(String str, String old, String newStr){
		return str.replaceAll(old, newStr);
	}


	/**
	 * 将字符串转换成GBK编码格式
	 * @param strVal 要转换的字符串
	 * @return 从“ISO8859_1”到“GBK”得到的字符串
	 * @since  1.0
	 */
	public static String toChinese(String strVal) {
		try {
			if (strVal == null) {
				return "";
			} else {
				strVal = strVal.trim();
				strVal = new String(strVal.getBytes("ISO8859_1"), "GBK");
				return strVal;
			}
		} catch (Exception exp) {
			return "";
		}
	}


	/**
	 *实际处理 return toChineseNoReplace(null2Blank(str));
	 *主要应用于老牛的信息发布
	 *@param str 要进行处理的字符串
	 *@return 转换后的字符串

	 */
	public static String toChineseAndHtmlEncode(String str, int quotes) {
		return htmlEncode(toChinese(str), quotes);
	}

	/**
	 * 用于将字符串中的特殊字符转换成Web页中可以安全显示的字符串
	 * 可对表单数据据进行处理对一些页面特殊字符进行处理如'<','>','"',''','&'
	 * @param strSrc 要进行替换操作的字符串
	 * @return 替换特殊字符后的字符串
	 * @since  1.0
	 */

	public static String htmlEncode(String strSrc) {
		if (strSrc == null)
			return "";

		char[] arr_cSrc = strSrc.toCharArray();
		StringBuffer buf = new StringBuffer(arr_cSrc.length);
		char ch;

		for (int i = 0; i < arr_cSrc.length; i++) {
			ch = arr_cSrc[i];

			if (ch == '<')
				buf.append("&lt;");
			else if (ch == '>')
				buf.append("&gt;");
			else if (ch == '"')
				buf.append("&quot;");
			else if (ch == '\'')
				buf.append("&#039;");
			else if (ch == '&')
				buf.append("&amp;");
			else
				buf.append(ch);
		}

		return buf.toString();
	}

	/**
	 * 用于将字符串中的特殊字符转换成Web页中可以安全显示的字符串
	 * 可对表单数据据进行处理对一些页面特殊字符进行处理如'<','>','"',''','&'
	 * @param strSrc 要进行替换操作的字符串
	 * @param quotes 为0时单引号和双引号都替换，为1时不替换单引号，为2时不替换双引号，为3时单引号和双引号都不替换
	 * @return 替换特殊字符后的字符串
	 * @since  1.0
	 */
	public static String htmlEncode(String strSrc, int quotes) {

		if (strSrc == null)
			return "";
		if (quotes == 0) {
			return htmlEncode(strSrc);
		}

		char[] arr_cSrc = strSrc.toCharArray();
		StringBuffer buf = new StringBuffer(arr_cSrc.length);
		char ch;

		for (int i = 0; i < arr_cSrc.length; i++) {
			ch = arr_cSrc[i];
			if (ch == '<')
				buf.append("&lt;");
			else if (ch == '>')
				buf.append("&gt;");
			else if (ch == '"' && quotes == 1)
				buf.append("&quot;");
			else if (ch == '\'' && quotes == 2)
				buf.append("&#039;");
			else if (ch == '&')
				buf.append("&amp;");
			else
				buf.append(ch);
		}

		return buf.toString();
	}


	/**
	 * 将字符串转换成UTF-8编码格式
	 * @param strVal 要转换的字符串
	 * @return 从“GBK”到“UTF-8”得到的字符串
	 * @since  1.0
	 */
	public static String gbk2UTF8(String strVal) {
		try {
			if (strVal == null) {
				return "";
			} else {
				strVal = new String(strVal.getBytes("GBK"), "UTF-8");
				return strVal;
			}
		} catch (Exception exp) {
			return "";
		}
	}

	/**
	 * 编码转换 从UTF-8到GBK
	 * @param strVal
	 * @return
	 */
	public static String toGBK(String strVal) {
		try {
			if (strVal == null) {
				return "";
			} else {
				strVal = strVal.trim();
				strVal = new String(strVal.getBytes("UTF-8"), "GBK");
				return strVal;
			}
		} catch (Exception exp) {
			return "";
		}
	}
	/**
	 * 将字符串转换成UTF-8编码格式
	 * @param strVal 要转换的字符串
	 * @return 从“ISO-8859-1”到“UTF-8”得到的字符串
	 * @since  1.0
	 */
	public static String ISO2UTF8(String strVal) {
		try {
			if (strVal == null) {
				return "";
			} else {
				strVal = new String(strVal.getBytes("ISO-8859-1"), "UTF-8");
				return strVal;
			}
		} catch (Exception exp) {
			return "";
		}
	}
	/**
	 * 转换编码 ISO-8859-1到GB2312
	 * @param text
	 * @return
	 */
	public static final String ISO2GB(String text) {
		String result = "";
		try {
			result = new String(text.getBytes("ISO-8859-1"), "GB2312");
		}
		catch (UnsupportedEncodingException ex) {
			result = ex.toString();
		}
		return result;
	}

	/**
	 * 转换编码 GB2312到ISO-8859-1
	 * @param text
	 * @return
	 */
	public static final String GB2ISO(String text) {
		String result = "";
		try {
			result = new String(text.getBytes("GB2312"), "ISO-8859-1");
		}
		catch (UnsupportedEncodingException ex) {
			ex.printStackTrace();
		}
		return result;
	}

	/**
	 * 将字符串转换成ISO8859-1编码格式
	 * @param strVal 要转换的字符串
	 * @return 从“GBK”到“ISO8859_1”得到的字符串
	 * @since  1.0
	 */
	public static String toISO(String strVal) {
		try {
			if (strVal == null) {
				return "";
			} else {
				strVal = new String(strVal.getBytes("GBK"), "ISO8859_1");
				return strVal;
			}
		} catch (Exception exp) {
			return "";
		}
	}



	/**
	 * Utf8URL编码
	 * @param text
	 * @return
	 */
	public static final String Utf8URLencode(String text) {
		StringBuffer result = new StringBuffer();

		for (int i = 0; i < text.length(); i++) {

			char c = text.charAt(i);
			if (c >= 0 && c <= 255) {
				result.append(c);
			}else {

				byte[] b = new byte[0];
				try {
					b = Character.toString(c).getBytes("UTF-8");
				}catch (Exception ex) {
				}

				for (int j = 0; j < b.length; j++) {
					int k = b[j];
					if (k < 0) k += 256;
					result.append("%" + Integer.toHexString(k).toUpperCase());
				}

			}
		}

		return result.toString();
	}

	/**
	 * Utf8URL解码
	 * @param text
	 * @return
	 */
	public static final String Utf8URLdecode(String text) {
		String result = "";
		int p = 0;

		if (text!=null && text.length()>0){
			text = text.toLowerCase();
			p = text.indexOf("%e");
			if (p == -1) return text;

			while (p != -1) {
				result += text.substring(0, p);
				text = text.substring(p, text.length());
				if (text == "" || text.length() < 9) return result;

				result += CodeToWord(text.substring(0, 9));
				text = text.substring(9, text.length());
				p = text.indexOf("%e");
			}

		}

		return result + text;
	}

	/**
	 * utf8URL编码转字符
	 * @param text
	 * @return
	 */
	private static final String CodeToWord(String text) {
		String result;

		if (Utf8codeCheck(text)) {
			byte[] code = new byte[3];
			code[0] = (byte) (Integer.parseInt(text.substring(1, 3), 16) - 256);
			code[1] = (byte) (Integer.parseInt(text.substring(4, 6), 16) - 256);
			code[2] = (byte) (Integer.parseInt(text.substring(7, 9), 16) - 256);
			try {
				result = new String(code, "UTF-8");
			}catch (UnsupportedEncodingException ex) {
				result = null;
			}
		}
		else {
			result = text;
		}

		return result;
	}

	/**
	 * 编码是否有效
	 * @param text
	 * @return
	 */
	private static final boolean Utf8codeCheck(String text){
		String sign = "";
		if (text.startsWith("%e"))
			for (int p = 0; p != -1;) {
				p = text.indexOf("%", p);
				if (p != -1)
					p++;
				sign += p;
			}
		return sign.equals("147-1");
	}

	/**
	 * 判断是否Utf8Url编码
	 * @param text
	 * @return
	 */
	public static final boolean isUtf8Url(String text) {
		text = text.toLowerCase();
		int p = text.indexOf("%");
		if (p != -1 && text.length() - p > 9) {
			text = text.substring(p, p + 9);
		}
		return Utf8codeCheck(text);
	}

	/**
	 * 将字符串转换成ISO8859-1编码格式
	 * @param strVal 要转换的字符串
	 * @return 从“UTF-8”到“ISO-8859-1”得到的字符串
	 * @since  1.0
	 */
	public static String UTF82ISO(String strVal) {
		try {
			if (strVal == null) {
				return "";
			} else {
				strVal = new String(strVal.getBytes("UTF-8"), "ISO-8859-1");
				return strVal;
			}
		} catch (Exception exp) {
			return "";
		}
	}


	/**
	 * 字符串从GBK编码转换为Unicode编码
	 * @param text
	 * @return
	 */
	public static String StringToUnicode(String text) {
		String result = "";
		int input;
		StringReader isr;
		try {
			isr = new StringReader(new String(text.getBytes(), "GBK"));
		} catch (UnsupportedEncodingException e) {
			return "-1";
		}
		try {
			while ((input = isr.read()) != -1) {
				result = result + "&#x" + Integer.toHexString(input) + ";";

			}
		} catch (IOException e) {
			return "-2";
		}
		isr.close();
		return result;

	}


	/**
	 *  将字符串dataStr编码为unicode
	 * This method will encode the String to unicode.
	 *
	 * @param gbString
	 * @return
	 */

	//代码:--------------------------------------------------------------------------------
	public static String gbEncoding(final String gbString) {
		char[] utfBytes = gbString.toCharArray();
		String unicodeBytes = "";
		for (int byteIndex = 0; byteIndex < utfBytes.length; byteIndex++) {
			String hexB = Integer.toHexString(utfBytes[byteIndex]);
			if (hexB.length() <= 2) {
				hexB = "00" + hexB;
			}
			unicodeBytes = unicodeBytes + "\\u" + hexB;
		}
		System.out.println("unicodeBytes is: " + unicodeBytes);
		return unicodeBytes;
	}

	/**
	 * 将dataStr解码
	 *
	 * This method will decode the String to a recognized String
	 * in ui.
	 * @param dataStr
	 * @return
	 */
	public static StringBuffer decodeUnicode(final String dataStr) {
		int start = 0;
		int end = 0;
		final StringBuffer buffer = new StringBuffer();
		while (start > -1) {
			end = dataStr.indexOf("\\u", start + 2);
			String charStr = "";
			if (end == -1) {
				charStr = dataStr.substring(start + 2, dataStr.length());
			} else {
				charStr = dataStr.substring(start + 2, end);
			}
			char letter = (char) Integer.parseInt(charStr, 16); // 16进制parse整形字符串。
			buffer.append(new Character(letter).toString());
			start = end;
		}
		return buffer;
	}

	/**
	 *显示大文本块处理(将字符集转成ISO)
	 *@deprecated
	 *@param str 要进行转换的字符串
	 *@return 转换成html可以正常显示的字符串
	 */
	public static String toISOHtml(String str) {
		return toISO(htmlDecode(isNull((str))));
	}

	/**
	 * 和htmlEncode正好相反
	 * @param strSrc 要进行转换的字符串
	 * @return 转换后的字符串
	 * @since  1.0
	 */
	public static String htmlDecode(String strSrc) {
		if (strSrc == null)
			return "";
		strSrc = strSrc.replaceAll("&lt;", "<");
		strSrc = strSrc.replaceAll("&gt;", ">");
		strSrc = strSrc.replaceAll("&quot;", "\"");
		strSrc = strSrc.replaceAll("&#039;", "'");
		strSrc = strSrc.replaceAll("&amp;", "&");
		return strSrc;
	}

	/**
	 *把null值和""值转换成&nbsp;
	 *主要应用于页面表格格的显示
	 *@param str 要进行处理的字符串
	 *@return 转换后的字符串
	 */
	public static String str4Table(String str) {
		if (str == null)
			return "&nbsp;";
		else if (str.equals(""))
			return "&nbsp;";
		else
			return str;
	}



	/**
	 * String型变量转换成int型变量
	 * @param str 要进行转换的字符串
	 * @return intVal 如果str不可以转换成int型数据，返回0表示异常,否则返回转换后的值
	 * @since  1.0
	 */
	public static int str2Int(String str) {
		int intVal;

		try {
			intVal = Integer.parseInt(str);
		} catch (Exception e) {
			intVal = 0;
		}

		return intVal;
	}
	/**
	 * String型变量转换成double型变量
	 * @param str 要进行转换的字符串
	 * @return intVal 如果str不可以转换成double型数据，返回0表示异常,否则返回转换后的值
	 * @since  1.0
	 */
	public static double str2Double(String str) {
		double dVal = 0;

		try {
			dVal = Double.parseDouble(str);
		} catch (Exception e) {
			dVal = 0;
		}

		return dVal;
	}

	/**
	 * String型变量转换成long型变量
	 * @param str 要进行转换的字符串
	 * @return intVal 如果str不可以转换成long型数据，返回0表示异常,否则返回转换后的值
	 * @since  1.0
	 */
	public static long str2Long(String str) {
		long longVal = 0;

		try {
			longVal = Long.parseLong(str);
		} catch (Exception e) {
			longVal = 0;
		}

		return longVal;
	}

	/**
	 *
	 * 将字符串转换成浮点类型
	 * @updateTime 2015-3-3
	 *
	 * */
	public static float stringToFloat(String value){
		float result = 0;
		try{
			result = Float.valueOf(value);
		} catch (Exception e) {
			result = 0;
		}
		return result;
	}


	/**
	 *int型变量转换成String型变量
	 *@param intVal 要进行转换的整数
	 *@return str 如果intVal不可以转换成String型数据，返回空值表示异常,否则返回转换后的值
	 */
	public static String int2Str(int intVal) {
		String str;

		try {
			str = String.valueOf(intVal);
		} catch (Exception e) {
			str = "";
		}

		return str;
	}

	/**
	 *long型变量转换成String型变量
	 *@param longVal 要进行转换的整数
	 *@return str 如果longVal不可以转换成String型数据，返回空值表示异常,否则返回转换后的值
	 */

	public static String long2Str(long longVal) {
		String str;

		try {
			str = String.valueOf(longVal);
		} catch (Exception e) {
			str = "";
		}
		return str;
	}
	/**
	 * float型变量转换成String型变量
	 * @param value 要进行转换的值
	 * @return String
	 * @since  1.0
	 */
	public static String floatToString(float value) {
		Float floatee = new Float(value);
		return floatee.toString();
	}


	/**
	 *把null转换为字符串"0"
	 *@param str 要进行转换的字符串
	 *@return 如果str为null值，返回空串整数0,否则返回相应的整数
	 */
	public static int null2Zero(String str) {
		int intTmp;
		intTmp = str2Int(str);
		return intTmp;
	}

	/**
	 * sql语句 处理
	 * @param sql 要进行处理的sql语句
	 * @param dbtype 数据库类型
	 * @return 处理后的sql语句
	 */
	public static String sql4DB(String sql, String dbtype) {
		if (!dbtype.equalsIgnoreCase("oracle")) {
			sql = toISO(sql);
		}
		return sql;
	}


	/**
	 * 将字符串倒置数组，并使用指定的分隔符合并成一个字符串。
	 * @param array 字符串数组
	 * @param delim 分隔符，为null的时候使用""作为分隔符（即没有分隔符）
	 * @return 合并后的字符串
	 * @since  0.4
	 */
	public static final String combineStringArray(String[] array, String delim) {
		int length = array.length - 1;
		if (delim == null) {
			delim = "";
		}
		StringBuffer result = new StringBuffer(length * 8);
		for (int i = length; i >=0; i--) {
			result.append(array[i]);
			result.append(delim);
		}
		String result2=result.substring(0, result.length()-1);
		return result2;
	}

	@SuppressWarnings("unused")
	public static void main(String[] args) throws Exception {

		String str = "VIDO_LOGIN_4b04a526448d4c7b8ecdd8ec5fe81fb6";
		System.out.println(str.substring(0, str.lastIndexOf("_")));

//		System.out.println(hideChar("sssdd", 2));
//		System.out.println(hideLastChar(hideFirstChar("sssdd"),3));
//		System.out.println(hideLastChar("ffdsffsd", 5));
//		System.out.println(format("vdvdvdvdvdv",20));
//		Date[] dd=new Date[]{new Date(),new Date(),new Date(),new Date(),new Date(),new Date()};
//		System.out.println(hideStr("dfdfeecxdsss", 3, 5));
//		String[] ddf= new String[]{"4444444"};
//		System.out.println(fillTemplet("ddffddffd", "ff",ddf));
//		System.out.println(string2Date("2015-03-03 15:32:38"));
//		System.out.println(replace("This is dog", "dog", "cat"));
//		System.out.println(null2Zero(""));
//		System.out.println("我的长度："+ridSpace("  s s  "));
//
//
//	    String url;
//
//	    url = "http://www.google.com/search?hl=zh-CN&newwindow=1&q=%E4%B8%AD%E5%9B%BD%E5%A4%A7%E7%99%BE%E7%A7%91%E5%9C%A8%E7%BA%BF%E5%85%A8%E6%96%87%E6%A3%80%E7%B4%A2&btnG=%E6%90%9C%E7%B4%A2&lr=";
//	    if(isUtf8Url(url)){
//	      System.out.println(Utf8URLdecode(url));
//	    }else{
//	      //System.out.println(URLDecoder.decode(url));
//	    }
//
//	    url = "http://www.baidu.com/baidu?word=%D6%D0%B9%FA%B4%F3%B0%D9%BF%C6%D4%DA%CF%DF%C8%AB%CE%C4%BC%EC%CB%F7&tn=myie2dg";
//	    if(isUtf8Url(url)){
//	      System.out.println(Utf8URLdecode(url));
//	    }else{
//	      //System.out.println(URLDecoder.decode(url));
//	    }

	}

	public static boolean isNotEmpty(String str){
		if(null == str || "".equals(str) ||  "".equals(str.trim()) || "null".equalsIgnoreCase(str.trim())){
			return false;
		}else {
			return true;
		}
	}

	/**
	 * 隐藏银行卡号
	 * @param bankCode
	 * @return
	 */
	public static String isHideBankCode(String bankCode){
		String _bankCode = "";
		if(isNotEmpty(bankCode) && bankCode.length()>6){
			_bankCode = bankCode.substring(0,6)+" **** **** "+bankCode.substring(bankCode.length()-4);
		}
		return _bankCode;
	}





}
